package com.zhc.validate.parser;

import com.zhc.validate.entity.Parameter;

import java.lang.reflect.*;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class TypeParser {
    public static void parse(Parameter parameter) {
        Type type = parameter.getType();
        // 判断 Type 的类型
        if (type instanceof Class) {
            Class<?> clazz = (Class<?>) type;
            // 处理基本类型和包装类型
            if (clazz == int.class || clazz == Integer.class) {
                System.out.println("int type");
            }

            // 处理 String 类型
            else if (clazz == String.class) {
//                parameter.setType("String");
            }
            // 处理日期类型
            else if (clazz == java.util.Date.class) {
//                parameter.setType("Date");
            } else if (clazz == java.time.LocalDate.class) {
//                parameter.setType("LocalDate");
            } else if (clazz == java.time.LocalDateTime.class) {
//                parameter.setType("LocalDateTime");
            }
            // 处理枚举类型
            else if (clazz.isEnum()) {
//                parameter.setType("Enum: " + clazz.getSimpleName());
            }
            // 处理集合类型
            else if (List.class.isAssignableFrom(clazz)) {
//                parameter.setType("List");
            } else if (Set.class.isAssignableFrom(clazz)) {
//                parameter.setType("Set");
            }
            // 处理 Map 类型
            else if (Map.class.isAssignableFrom(clazz)) {
//                parameter.setType("Map");
            }
            // 处理数组类型
            else if (clazz.isArray()) {
                System.out.println("Array Type");
//                parameter.setType("Array: " + clazz.getComponentType().getSimpleName());
            }
            // 普通类类型
            else {
//                parameter.setType("Class: " + clazz.getName());
            }
        }
        // 处理泛型类型
        else if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            StringBuilder typeInfo = new StringBuilder("ParameterizedType: ");
            for (Type arg : actualTypeArguments) {
                typeInfo.append(arg.getTypeName()).append(" ");
            }
//            parameter.setType(typeInfo.toString().trim());
        }
        // 处理数组泛型类型
        else if (type instanceof GenericArrayType) {
            GenericArrayType arrayType = (GenericArrayType) type;
            Type componentType = arrayType.getGenericComponentType();
//            parameter.setType("GenericArrayType: " + componentType.getTypeName());
        }
        // 处理通配符类型
        else if (type instanceof WildcardType) {
            WildcardType wildcardType = (WildcardType) type;
            Type[] upperBounds = wildcardType.getUpperBounds();
            Type[] lowerBounds = wildcardType.getLowerBounds();
            StringBuilder typeInfo = new StringBuilder("WildcardType: ");
            for (Type bound : upperBounds) {
                typeInfo.append("? extends ").append(bound.getTypeName()).append(" ");
            }
            for (Type bound : lowerBounds) {
                typeInfo.append("? super ").append(bound.getTypeName()).append(" ");
            }
//            parameter.setType(typeInfo.toString().trim());
        }
        // 处理类型变量
        else if (type instanceof TypeVariable) {
            TypeVariable<?> typeVariable = (TypeVariable<?>) type;
//            parameter.setType("TypeVariable: " + typeVariable.getName());
        } else {
//            parameter.setType("Unknown Type");
        }
    }

}
